Delayed Shutter Camera

#include "esp_camera.h"
#include <WiFi.h>
#include <WebServer.h>
#include <time.h>

// WiFi credentials - CHANGE THESE
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";

// Button pins
const int BUTTON_1 = D0;  // 30 seconds
const int BUTTON_2 = D1;  // 1 hour
const int BUTTON_3 = D2;  // 24 hours
const int LED_PIN = D9;

WebServer server(80);

struct ImageData {
  uint8_t* buffer;
  size_t length;
  String timestamp;
  String buttonName;
  String delayInfo;
  bool available;
  int imageID;
} latestImage;

int totalImagesCaptured = 0;

struct ScheduledCapture {
  bool active;
  unsigned long captureTime;
  String buttonName;
  String delayName;
};

#define MAX_SCHEDULED 10
ScheduledCapture scheduled[MAX_SCHEDULED];

bool button1LastState = HIGH;
bool button2LastState = HIGH;
bool button3LastState = HIGH;

// Camera pins for Xiao ESP32S3 Sense
#define PWDN_GPIO_NUM     -1
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM     10
#define SIOD_GPIO_NUM     40
#define SIOC_GPIO_NUM     39
#define Y9_GPIO_NUM       48
#define Y8_GPIO_NUM       11
#define Y7_GPIO_NUM       12
#define Y6_GPIO_NUM       14
#define Y5_GPIO_NUM       16
#define Y4_GPIO_NUM       18
#define Y3_GPIO_NUM       17
#define Y2_GPIO_NUM       15
#define VSYNC_GPIO_NUM    38
#define HREF_GPIO_NUM     47
#define PCLK_GPIO_NUM     13

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("\n\n=== ESP32 Delayed Shutter Camera ===");
  
  latestImage.buffer = NULL;
  latestImage.available = false;
  latestImage.imageID = 0;
  
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, HIGH);  // OFF (inverted logic)
  
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);
  
  pinMode(BUTTON_1, INPUT_PULLUP);
  pinMode(BUTTON_2, INPUT_PULLUP);
  pinMode(BUTTON_3, INPUT_PULLUP);
  
  for(int i = 0; i < MAX_SCHEDULED; i++) {
    scheduled[i].active = false;
  }
  
  Serial.println("Initializing camera...");
  if(!initCamera()) {
    Serial.println("Camera init failed!");
    while(1) { 
      digitalWrite(LED_PIN, !digitalRead(LED_PIN));
      delay(200);
    }
  }
  Serial.println("Camera OK!");
  
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.println("========================================");
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());
  Serial.println("========================================");
  
  configTime(0, 0, "pool.ntp.org", "time.nist.gov");
  setenv("TZ", "EST5EDT,M3.2.0,M11.1.0", 1);
  tzset();
  
  server.on("/", handleRoot);
  server.on("/status", handleStatus);
  server.on("/latest", handleLatest);
  server.on("/download", handleDownload);
  
  server.begin();
  Serial.println("Ready!\n");
}

void loop() {
  server.handleClient();
  
  for(int i = 0; i < MAX_SCHEDULED; i++) {
    if(scheduled[i].active && millis() >= scheduled[i].captureTime) {
      digitalWrite(LED_PIN, HIGH);
      captureImage(scheduled[i].buttonName, scheduled[i].delayName);
      delay(1000);
      digitalWrite(LED_PIN, LOW);
      scheduled[i].active = false;
    }
  }
  
  bool button1State = digitalRead(BUTTON_1);
  bool button2State = digitalRead(BUTTON_2);
  bool button3State = digitalRead(BUTTON_3);
  
  if(button1LastState == HIGH && button1State == LOW) {
    scheduleCapture(30000, "Button1_30sec", "30 seconds");
  }
  button1LastState = button1State;
  
  if(button2LastState == HIGH && button2State == LOW) {
    scheduleCapture(3600000, "Button2_1hr", "1 hour");
  }
  button2LastState = button2State;
  
  if(button3LastState == HIGH && button3State == LOW) {
    scheduleCapture(86400000, "Button3_24hr", "24 hours");
  }
  button3LastState = button3State;
  
  delay(50);
}

void scheduleCapture(unsigned long delayMs, String buttonName, String delayName) {
  int slot = -1;
  for(int i = 0; i < MAX_SCHEDULED; i++) {
    if(!scheduled[i].active) {
      slot = i;
      break;
    }
  }
  
  if(slot == -1) {
    Serial.println("Too many scheduled!");
    for(int i = 0; i < 3; i++) {
      digitalWrite(LED_PIN, HIGH);
      delay(100);
      digitalWrite(LED_PIN, LOW);
      delay(100);
    }
    return;
  }
  
  scheduled[slot].active = true;
  scheduled[slot].captureTime = millis() + delayMs;
  scheduled[slot].buttonName = buttonName;
  scheduled[slot].delayName = delayName;
  
  digitalWrite(LED_PIN, HIGH);
  Serial.println("\n>>> " + buttonName + " SCHEDULED <<<");
  delay(300);
  digitalWrite(LED_PIN, LOW);
}

bool initCamera() {
  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;
  config.frame_size = FRAMESIZE_SVGA;
  config.jpeg_quality = 10;
  config.fb_count = 1;
  
  return (esp_camera_init(&config) == ESP_OK);
}

void captureImage(String buttonName, String delayInfo) {
  camera_fb_t * fb = esp_camera_fb_get();
  if(!fb) return;
  
  if(latestImage.buffer != NULL) free(latestImage.buffer);
  
  latestImage.buffer = (uint8_t*)malloc(fb->len);
  if(latestImage.buffer != NULL) {
    memcpy(latestImage.buffer, fb->buf, fb->len);
    latestImage.length = fb->len;
    latestImage.timestamp = getTimestamp();
    latestImage.buttonName = buttonName;
    latestImage.delayInfo = delayInfo;
    latestImage.available = true;
    latestImage.imageID++;
    totalImagesCaptured++;
  }
  
  esp_camera_fb_return(fb);
}

String getTimestamp() {
  struct tm timeinfo;
  if(!getLocalTime(&timeinfo)) return String(millis());
  char buffer[80];
  strftime(buffer, sizeof(buffer), "%Y-%m-%d_%H-%M-%S", &timeinfo);
  return String(buffer);
}

void handleRoot() {
  String html = "<html><body><h1>ESP32 Camera</h1>";
  html += "<p>Images captured: " + String(totalImagesCaptured) + "</p>";
  html += "<p><a href='/status'>Status</a> | <a href='/download'>Download</a></p>";
  html += "</body></html>";
  server.send(200, "text/html", html);
}

void handleStatus() {
  String json = "{\"available\":" + String(latestImage.available ? "true" : "false");
  json += ",\"imageID\":" + String(latestImage.imageID);
  json += ",\"totalCaptured\":" + String(totalImagesCaptured);
  json += ",\"timestamp\":\"" + latestImage.timestamp + "\"";
  json += ",\"buttonName\":\"" + latestImage.buttonName + "\"";
  json += ",\"delayInfo\":\"" + latestImage.delayInfo + "\"}";
  server.send(200, "application/json", json);
}

void handleLatest() {
  if(latestImage.available && latestImage.buffer != NULL) {
    server.send_P(200, "image/jpeg", (const char*)latestImage.buffer, latestImage.length);
  } else {
    server.send(404, "text/plain", "No image");
  }
}

void handleDownload() {
  if(latestImage.available && latestImage.buffer != NULL) {
    String filename = latestImage.buttonName + "_" + latestImage.timestamp + ".jpg";
    server.sendHeader("Content-Disposition", "attachment; filename=\"" + filename + "\"");
    server.send_P(200, "image/jpeg", (const char*)latestImage.buffer, latestImage.length);
  } else {
    server.send(404, "text/plain", "No image");
  }
}

#!/usr/bin/env python3
import requests
import os
import time
from datetime import datetime
from flask import Flask, render_template_string, send_from_directory
import threading

ESP32_IP = "192.168.72.72"
DOWNLOAD_FOLDER = "/path/to/your/images"
CHECK_INTERVAL = 5
WEB_PORT = 8765

os.makedirs(DOWNLOAD_FOLDER, exist_ok=True)
last_image_id = 0
app = Flask(__name__)

GALLERY_TEMPLATE = """
<!DOCTYPE html>
<html>
<head>
    <title>Camera Feed</title>
    <meta http-equiv="refresh" content="10">
    <style>
        body { font-family: Arial, sans-serif; margin: 0; padding: 20px; background: #fff; }
        table { border-collapse: separate; border-spacing: 20px; width: 100%; table-layout: fixed; }
        td { padding: 0; width: 33.33%; }
        img { width: 100%; height: auto; display: block; }
        .info { font-size: 14px; color: #666; padding: 10px 0; text-align: center; }
        .delay { color: #999; font-size: 12px; }
    </style>
</head>
<body>
    {% if images %}
        <table>
            {% for row in images | batch(3) %}
            <tr>
                {% for image in row %}
                <td>
                    <img src="/images/{{ image.filename }}" alt="Capture">
                    <div class="info">
                        {{ image.timestamp }}<br>
                        <span class="delay">{{ image.delay }}</span>
                    </div>
                </td>
                {% endfor %}
            </tr>
            {% endfor %}
        </table>
    {% else %}
        <p style="color: #666; text-align: center;">No images yet.</p>
    {% endif %}
</body>
</html>
"""

def download_new_image():
    global last_image_id
    try:
        response = requests.get(f"http://{ESP32_IP}/status", timeout=5)
        if response.status_code != 200:
            return False
        
        data = response.json()
        if not data['available']:
            return False
        
        current_id = data['imageID']
        if current_id <= last_image_id:
            return False
        
        print(f"\n>>> New image detected! ID: {current_id}")
        img_response = requests.get(f"http://{ESP32_IP}/latest", timeout=10)
        
        if img_response.status_code == 200:
            filename = f"{data['buttonName']}_{data['timestamp']}.jpg"
            filepath = os.path.join(DOWNLOAD_FOLDER, filename)
            
            with open(filepath, 'wb') as f:
                f.write(img_response.content)
            
            print(f"✓ Downloaded: {filename}")
            last_image_id = current_id
            return True
        
    except Exception as e:
        print(f"Error: {e}")
        return False

def monitor_loop():
    print(f"\n=== Monitoring ESP32 at {ESP32_IP} ===")
    while True:
        download_new_image()
        time.sleep(CHECK_INTERVAL)

@app.route('/')
def gallery():
    images = []
    if os.path.exists(DOWNLOAD_FOLDER):
        for filename in sorted(os.listdir(DOWNLOAD_FOLDER), reverse=True):
            if filename.endswith('.jpg'):
                parts = filename.replace('.jpg', '').split('_')
                button = parts[0] if len(parts) > 0 else "Unknown"
                delay = parts[1] if len(parts) > 1 else "Unknown"
                timestamp = "Unknown"
                if len(parts) >= 4:
                    timestamp = f"{parts[2]} {parts[3].replace('-', ':')}"
                
                images.append({
                    'filename': filename,
                    'button': button,
                    'delay': delay,
                    'timestamp': timestamp
                })
    
    return render_template_string(GALLERY_TEMPLATE, images=images)

@app.route('/images/<filename>')
def serve_image(filename):
    return send_from_directory(DOWNLOAD_FOLDER, filename)

if __name__ == '__main__':
    print("=" * 50)
    print("ESP32 Camera Downloader & Gallery")
    print("=" * 50)
    
    monitor_thread = threading.Thread(target=monitor_loop, daemon=True)
    monitor_thread.start()
    
    print(f"\n>>> Open http://localhost:{WEB_PORT} in browser <<<\n")
    app.run(host='0.0.0.0', port=WEB_PORT, debug=False)